#include "fenetrePrincipale.h"

#include "moteurGraphique.h"
#include "jeu.h"

//#include "dialogNouvellePartieLocale.h"
//#include "dialogNouvellePartieReseau.h"
//#include "dialogRejoindrePartieReseau.h"
//#include "dialogInviterAmi.h"
//#include "dialogScore.h"
//#include "dialogJoueur.h"
//#include "dialogTheme.h"
//#include "dialogAPropos.h"

FenetrePrincipale::FenetrePrincipale(MoteurGraphique *moteurGraphique) {
    // Référence au moteur
    moteur = moteurGraphique;

    // Création de la partie OpenGL
    jeu = new GLWidget(this);
    setCentralWidget(jeu);

    // Créations de toutes les actions et des menus
    creerActions();
    creerMenu();
    creerBarreStatus();

    resize(640, 640);
}

GLWidget * FenetrePrincipale::getGLWidget() const {
    return jeu;
}
MoteurGraphique * FenetrePrincipale::getParent() const {
    return moteur;
}


void FenetrePrincipale::closeEvent(QCloseEvent *event) {
    moteur->getParent()->arreter();
    event->accept();
}


// PUBLIC SLOTS
void FenetrePrincipale::validerPartieLocale(QString nom_jB, QString nom_jN) {
    Message msg(CREER_PARTIE);

    msg.ajouterJoueur(new Joueur((MoteurJeu *)(moteur->moteurJeu),"blanc",BLANC,0));
    // DEBUG
    //msg.ajouterJoueur(new JoueurIA((MoteurJeu *)(moteur->moteurJeu),"blanc",BLANC,0));

    msg.ajouterJoueur(new Joueur((MoteurJeu *)(moteur->moteurJeu),"noir",NOIR,0));
    // DEBUG
    //msg.ajouterJoueur(new JoueurIA((MoteurJeu *)(moteur->moteurJeu),"noir",NOIR,0));

    moteur->moteurJeu->envoyerMessage(msg);
}

void FenetrePrincipale::validerInviter(QString ip) {
    Message msg(DEMANDE_INVITATION);
    msg.ajouterChaine(ip.toStdString());
    moteur->moteurReseau->envoyerMessage(msg);
}



// Menu Jeu
void FenetrePrincipale::afficherNouvellePartieLocale() {
    DialogNouvellePartieLocale* d = new DialogNouvellePartieLocale(this);
    connect(d, SIGNAL(valider(QString,QString)), this, SLOT(validerPartieLocale(QString,QString)));
    d->setModal(true);
    d->show();
}

void FenetrePrincipale::afficherNouvellePartieReseau() {

}

void FenetrePrincipale::afficherRejoindrePartieReseau() {

}

void FenetrePrincipale::afficherInviterAmi() {
    DialogInviter* d = new DialogInviter(this);
    connect(d, SIGNAL(valider(QString)), this, SLOT(validerInviter(QString)));
    d->setModal(true);
    d->show();
}

void FenetrePrincipale::afficherChargerPartie() {

}

void FenetrePrincipale::afficherSauverPartie() {

}

void FenetrePrincipale::afficherScore() {

}

void FenetrePrincipale::afficherQuitter() {

}

// Préférences
void FenetrePrincipale::afficherJoueur() {

}

void FenetrePrincipale::afficherTheme() {

}

void FenetrePrincipale::afficherCamera(bool libre) {

}

// ?
void FenetrePrincipale::afficherAide() {

}

void FenetrePrincipale::afficherAPropos() {

}

void FenetrePrincipale::afficherAProposQT() {

}

void FenetrePrincipale::creerActions() {
    nouvellePartieLocale = new QAction(tr("&Locale"), this);
    nouvellePartieLocale->setStatusTip(tr("Creer une nouvelle partie locale"));
    nouvellePartieLocale->setShortcut(tr("Ctrl+N"));
    connect(nouvellePartieLocale, SIGNAL(triggered()), this, SLOT(afficherNouvellePartieLocale()));

    nouvellePartieReseau = new QAction(tr("Creer une &partie reseau"), this);
    nouvellePartieReseau->setStatusTip(tr("Creer une nouvelle partie en reseau"));
    nouvellePartieReseau->setShortcut(tr("Ctrl+P"));
    connect(nouvellePartieReseau, SIGNAL(triggered()), this, SLOT(afficherNouvellePartieReseau()));

    rejoindrePartie = new QAction(tr("&Rejoindre une partie reseau"), this);
    rejoindrePartie->setStatusTip(tr("Rejoindre une partie reseau existante"));
    rejoindrePartie->setShortcut(tr("Ctrl+R"));
    connect(rejoindrePartie, SIGNAL(triggered()), this, SLOT(afficherRejoindrePartieReseau()));

    inviter = new QAction(tr("&Inviter un ami"), this);
    inviter->setStatusTip(tr("Inviter un ami à jouer une partie d'echecs en reseau"));
    inviter->setShortcut(tr("Ctrl+I"));
    connect(inviter, SIGNAL(triggered()), this, SLOT(afficherInviterAmi()));

    chargerPartie = new QAction(tr("&Charger une partie"), this);
    chargerPartie->setStatusTip(tr("Permet de charger une partie enregistree precedemment"));
    chargerPartie->setShortcut(tr("Ctrl+C"));
    connect(chargerPartie, SIGNAL(triggered()), this, SLOT(afficherChargerPartie()));

    sauverPartie = new QAction(tr("&Sauvegarder une partie"), this);
    sauverPartie->setStatusTip(tr("Permet de sauvegarder une partie"));
    sauverPartie->setShortcut(tr("Ctrl+S"));
    sauverPartie->setEnabled(false);
    connect(sauverPartie, SIGNAL(triggered()), this, SLOT(afficherSauverPartie()));

    score = new QAction(tr("Sc&ore"), this);
    score->setStatusTip(tr("Afficher les scores des differents joueurs"));
    score->setShortcut(tr("Ctrl+O"));
    connect(score, SIGNAL(triggered()), this, SLOT(afficherScore()));

    quitter = new QAction(tr("&Quitter"), this);
    quitter->setStatusTip(tr("Quitter le programme"));
    quitter->setShortcut(tr("Ctrl+Q"));
    connect(quitter, SIGNAL(triggered()), this, SLOT(afficherQuitter()));

    joueur = new QAction(tr("&Joueurs"), this);
    joueur->setStatusTip(tr("Gerer les profils des joueurs"));
    joueur->setShortcut(tr("Ctrl+J"));
    connect(joueur, SIGNAL(triggered()), this, SLOT(afficherJoueur()));

    theme = new QAction(tr("&Themes"), this);
    theme->setStatusTip(tr("Changer les couleurs du jeu"));
    theme->setShortcut(tr("Ctrl+T"));
    connect(theme, SIGNAL(triggered()), this, SLOT(afficherTheme()));

    camera = new QAction(tr("Camera &Libre"), this);
    camera->setStatusTip(tr("Camera libre ou fixe"));
    camera->setShortcut(tr("Ctrl+L"));
    camera->setCheckable(true);
    camera->setChecked(false);
    connect(camera, SIGNAL(toggled(bool)), this, SLOT(afficherCamera(bool)));

    aide = new QAction(tr("&Aide"), this);
    aide->setStatusTip(tr("Afficher l'aide du jeu"));
    aide->setShortcut(tr("F1"));
    connect(aide, SIGNAL(triggered()), this, SLOT(afficherAide()));

    aPropos = new QAction(tr("A Propos"), this);
    aPropos->setStatusTip(tr("A propos de ChessNet3D"));
    connect(aPropos, SIGNAL(triggered()), this, SLOT(afficherAPropos()));

    aProposQT = new QAction(tr("A Propos de QT"), this);
    aProposQT->setStatusTip(tr("A propos de QT, librairie utilisee par ce programme"));
    connect(aProposQT, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
}

void FenetrePrincipale::creerMenu() {
    menuJeu = menuBar()->addMenu(tr("&Jeu"));
    menuJeu->addAction(nouvellePartieLocale);
    menuJeu->addAction(nouvellePartieReseau);
    menuJeu->addAction(rejoindrePartie);
    menuJeu->addAction(inviter);
    menuJeu->addSeparator();
    menuJeu->addAction(chargerPartie);
    menuJeu->addAction(sauverPartie);
    menuJeu->addSeparator();
    menuJeu->addAction(score);
    menuJeu->addSeparator();
    menuJeu->addAction(quitter);

    menuPreferences = menuBar()->addMenu(tr("&Preferences"));
    menuPreferences->addAction(joueur);
    menuPreferences->addAction(theme);
    menuPreferences->addAction(camera);

    menuAide = menuBar()->addMenu(tr("&Aide"));
    menuAide->addAction(aide);
    menuAide->addSeparator();
    menuAide->addAction(aPropos);
    menuAide->addAction(aProposQT);
}

void FenetrePrincipale::creerBarreStatus() {

}
